Nun kommen wir zum Round Robin Verfahren. Das ist ein verdrängendes First-Come-First-Serve.

Es verwendet, um die Verdrängung zu realisieren, sogenannte Zeitschreiben und in dem es ein

verdrängendes Verfahren ist, implementiert es gleichzeitig CPU-Schutz. Hier werden wie

bei FCFS die Prozesse in ihrer Ankunftszeit einsortiert, aber sie werden in mehr oder

weniger regelmäßigen Abständen, periodisch nämlich, umgeplant. Da kann also dann durchaus

die Breitliste dieser Prozesse komplett umsortiert werden, nach gewissen Kriterien. Diese

Verdrängungstechnik, die man hier einsetzt, die nutzt periodische Unterbrechungen, die

kommen von einem Zeitgeber, das ist ein Timer Interrupt, der liefert dann also asynchrotische

Programmunterbrechungen, entsprechend voreingestellter Zeitlängen. Diese Zeitlängen, auch Zeitscheiben,

Timeslice genannt, werden den Prozessen dann zugeteilt. Für gewöhnlich hat man in solchen

Systemen eine systemweit definierte Zeitscheibenlänge, die dann also für alle diese Prozesse typischerweise

gelten. Und diese Zeitscheibe definiert dann letztendlich eine obere Schranke für die

Rechenstoßlänge des jeweils laufenden Prozesses. Wenn also der Rechenstoß länger ist als diese

Zeitscheibe lang ist, dann wird er vom Zeitgeber unterbrochen und es wird ein anderer Prozess,

so der denn verfügbar ist, dann zur Ausführung gebracht werden. Hier werden durchaus Benachteiligungen,

die wir denn bei FCFS vorher gerade kennengelernt haben, verringert. Sie werden nicht komplett

gelöst, die wir gleich sehen, werden aber schon merklich verringert. Es hängt aber dann davon ab,

wie lang die Zeitscheibe denn letztendlich definiert ist. Wenn diese Zeitscheibenlänge zu groß ist,

denn degeneriert de facto dieses Verfahren nach FCFS, weil ja immer FCFS praktisch als Grundlage

existiert, um den Prozess überhaupt einzureihen in die Warteschlange. Wenn wir die Zeitscheibenlänge

zu kurz definieren, dann heißt es, dass wir eine zu hohe Interruptfrequenz bekommen, dann heißt es,

dass wir zu viele Unterbrechungen innerhalb einer bestimmten Zeitspanne bekommen werden und damit

viel zu viel Overhead-Mehraufwand im Rechensystem generieren. Hier muss man also die Zeitscheibenlänge

wohl definieren und da gibt es eine Faustregel, die sagt, die sollte etwas länger sein als die

Dauer eines typischen Rechenstoßes. Nun, diese Länge eines typischen Rechenstoßes kriegt man

dann eigentlich nur aus, indem man sozusagen mal Testläufe mit seinem generierten Betriebssystem

durchführt für einen bestimmten Anwendungsfall und dann einfach wirklich tatsächlich die einzelnen

Rechenstoßzeiten misst und auf Basis der dann gewonnenen Erkenntnisse einfach die Zeitscheibenlänge

dann letztendlich definiert. Heute reden wir von Zeitscheibenlängen, die liegen so im 100

Millisekunden, im 20 Millisekunden Bereich, je nachdem um welche Art von Betriebssystem es geht und

wie schnell der unterliegende Prozessor denn etwa läuft. Der Konvoieffekt ist durchaus immer noch

da, er ist nicht mehr so ganz ausgeprägt wie in dem reinen FCFS-Verfahren, aber hier werden wir,

wenn wir gleich noch betrachten, durchaus Situationen haben können, wo denn Prozesse,

die eben kürzer als eine Zeitscheibe laufen werden, denn praktisch immer Prozessen folgen,

die ihre Zeitscheibe voll ausnutzen und damit wir auch so eine Art Konvoiebildung von den ganz

kurzen Prozessen haben können. Die Zuteilung denn der Zeitscheiben an diese Prozesse läuft de facto

nach First-Come-First-Serve, wo die Prozesse entsprechend eingereiht werden. Wenn wir

sogenannte eine Ausgabe-intensive, also interaktive Prozesse halt haben, dann sind das Prozesse,

wie ich vorher schon nannte, die typischerweise ihre Zeitscheibe gar nicht ausschöpfen werden,

weil die immer einen sehr kurzen Rechenstoß halt haben. Die benötigen die CPU nur relativ kurz,

setzen den nächsten einen Ausgabeauftrag ab und dann warten sie dann darauf, dass dieser eine

Ausgabeauftrag beendet worden ist und das schaffen die normalerweise halt innerhalb ihrer Zeitscheibe.

Wohingegen die CPU-intensiven Prozesse, die CPU, den Speicher, den Hauptspeicher belegen und erst

praktisch diese Ressourcen freigeben, wenn sie dann verdrängt werden. Das heißt also hier haben

wir dann Prozesse, die eine Rechenstoßlänge haben, die typischerweise länger als die Zeitscheibe sind

und damit ihre Zeitscheibe vollständig ausnutzen werden. Beide Arten von Prozessen werden natürlich

der Nummerreihe unbedient. Das bringt dieses RR-Verfahren dann halt mit sich. Nun, wenn die

Zeitscheibe durch den Prozess nicht voll ausgeschöpft wird, dann werden wir über eine längere Zeit eine

Situation haben, wo die CPU-Zeit zu Ungunsten der sogenannten eine Ausgabe-intensiven Prozesse

verteilt wird. Das heißt also diese ein Ausgabe-intensiven interaktiven Prozesse